home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / compiler / transformer.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  42KB  |  1,427 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from compiler.ast import *
  5. import parser
  6. import symbol
  7. import token
  8. import sys
  9.  
  10. class WalkerError(StandardError):
  11.     pass
  12.  
  13. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
  14. from compiler.consts import OP_ASSIGN, OP_DELETE, OP_APPLY
  15.  
  16. def parseFile(path):
  17.     f = open(path, 'U')
  18.     src = f.read() + '\n'
  19.     f.close()
  20.     return parse(src)
  21.  
  22.  
  23. def parse(buf, mode = 'exec'):
  24.     if mode == 'exec' or mode == 'single':
  25.         return Transformer().parsesuite(buf)
  26.     elif mode == 'eval':
  27.         return Transformer().parseexpr(buf)
  28.     else:
  29.         raise ValueError("compile() arg 3 must be 'exec' or 'eval' or 'single'")
  30.  
  31.  
  32. def asList(nodes):
  33.     l = []
  34.     for item in nodes:
  35.         if hasattr(item, 'asList'):
  36.             l.append(item.asList())
  37.             continue
  38.         if type(item) is type((None, None)):
  39.             l.append(tuple(asList(item)))
  40.             continue
  41.         if type(item) is type([]):
  42.             l.append(asList(item))
  43.             continue
  44.         l.append(item)
  45.     
  46.     return l
  47.  
  48.  
  49. def extractLineNo(ast):
  50.     if not isinstance(ast[1], tuple):
  51.         return ast[2]
  52.     
  53.     for child in ast[1:]:
  54.         if isinstance(child, tuple):
  55.             lineno = extractLineNo(child)
  56.             if lineno is not None:
  57.                 return lineno
  58.             
  59.         lineno is not None
  60.     
  61.  
  62.  
  63. def Node(*args):
  64.     kind = args[0]
  65.     if nodes.has_key(kind):
  66.         
  67.         try:
  68.             return nodes[kind](*args[1:])
  69.         except TypeError:
  70.             print nodes[kind], len(args), args
  71.             raise 
  72.         except:
  73.             None<EXCEPTION MATCH>TypeError
  74.         
  75.  
  76.     None<EXCEPTION MATCH>TypeError
  77.     raise WalkerError, "Can't find appropriate Node type: %s" % str(args)
  78.  
  79.  
  80. class Transformer:
  81.     
  82.     def __init__(self):
  83.         self._dispatch = { }
  84.         for value, name in symbol.sym_name.items():
  85.             if hasattr(self, name):
  86.                 self._dispatch[value] = getattr(self, name)
  87.                 continue
  88.         
  89.         self._dispatch[token.NEWLINE] = self.com_NEWLINE
  90.         self._atom_dispatch = {
  91.             token.LPAR: self.atom_lpar,
  92.             token.LSQB: self.atom_lsqb,
  93.             token.LBRACE: self.atom_lbrace,
  94.             token.BACKQUOTE: self.atom_backquote,
  95.             token.NUMBER: self.atom_number,
  96.             token.STRING: self.atom_string,
  97.             token.NAME: self.atom_name }
  98.         self.encoding = None
  99.  
  100.     
  101.     def transform(self, tree):
  102.         if not isinstance(tree, tuple) or isinstance(tree, list):
  103.             tree = parser.ast2tuple(tree, line_info = 1)
  104.         
  105.         return self.compile_node(tree)
  106.  
  107.     
  108.     def parsesuite(self, text):
  109.         return self.transform(parser.suite(text))
  110.  
  111.     
  112.     def parseexpr(self, text):
  113.         return self.transform(parser.expr(text))
  114.  
  115.     
  116.     def parsefile(self, file):
  117.         if type(file) == type(''):
  118.             file = open(file)
  119.         
  120.         return self.parsesuite(file.read())
  121.  
  122.     
  123.     def compile_node(self, node):
  124.         n = node[0]
  125.         if n == symbol.encoding_decl:
  126.             self.encoding = node[2]
  127.             node = node[1]
  128.             n = node[0]
  129.         
  130.         if n == symbol.single_input:
  131.             return self.single_input(node[1:])
  132.         
  133.         if n == symbol.file_input:
  134.             return self.file_input(node[1:])
  135.         
  136.         if n == symbol.eval_input:
  137.             return self.eval_input(node[1:])
  138.         
  139.         if n == symbol.lambdef:
  140.             return self.lambdef(node[1:])
  141.         
  142.         if n == symbol.funcdef:
  143.             return self.funcdef(node[1:])
  144.         
  145.         if n == symbol.classdef:
  146.             return self.classdef(node[1:])
  147.         
  148.         raise WalkerError, ('unexpected node type', n)
  149.  
  150.     
  151.     def single_input(self, node):
  152.         n = node[0][0]
  153.         if n != token.NEWLINE:
  154.             return self.com_stmt(node[0])
  155.         
  156.         return Pass()
  157.  
  158.     
  159.     def file_input(self, nodelist):
  160.         doc = self.get_docstring(nodelist, symbol.file_input)
  161.         if doc is not None:
  162.             i = 1
  163.         else:
  164.             i = 0
  165.         stmts = []
  166.         for node in nodelist[i:]:
  167.             if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
  168.                 self.com_append_stmt(stmts, node)
  169.                 continue
  170.         
  171.         return Module(doc, Stmt(stmts))
  172.  
  173.     
  174.     def eval_input(self, nodelist):
  175.         return Expression(self.com_node(nodelist[0]))
  176.  
  177.     
  178.     def decorator_name(self, nodelist):
  179.         listlen = len(nodelist)
  180.         item = self.atom_name(nodelist)
  181.         i = 1
  182.         while i < listlen:
  183.             item = Getattr(item, nodelist[i + 1][1])
  184.             i += 2
  185.         return item
  186.  
  187.     
  188.     def decorator(self, nodelist):
  189.         funcname = self.decorator_name(nodelist[1][1:])
  190.         if len(nodelist) > 3:
  191.             expr = self.com_call_function(funcname, nodelist[3])
  192.         else:
  193.             expr = funcname
  194.         return expr
  195.  
  196.     
  197.     def decorators(self, nodelist):
  198.         items = []
  199.         for dec_nodelist in nodelist:
  200.             items.append(self.decorator(dec_nodelist[1:]))
  201.         
  202.         return Decorators(items)
  203.  
  204.     
  205.     def funcdef(self, nodelist):
  206.         if len(nodelist) == 6:
  207.             decorators = self.decorators(nodelist[0][1:])
  208.         else:
  209.             decorators = None
  210.         lineno = nodelist[-4][2]
  211.         name = nodelist[-4][1]
  212.         args = nodelist[-3][2]
  213.         if args[0] == symbol.varargslist:
  214.             (names, defaults, flags) = self.com_arglist(args[1:])
  215.         else:
  216.             names = defaults = ()
  217.             flags = 0
  218.         doc = self.get_docstring(nodelist[-1])
  219.         code = self.com_node(nodelist[-1])
  220.         if doc is not None:
  221.             del code.nodes[0]
  222.         
  223.         return Function(decorators, name, names, defaults, flags, doc, code, lineno = lineno)
  224.  
  225.     
  226.     def lambdef(self, nodelist):
  227.         if nodelist[2][0] == symbol.varargslist:
  228.             (names, defaults, flags) = self.com_arglist(nodelist[2][1:])
  229.         else:
  230.             names = defaults = ()
  231.             flags = 0
  232.         code = self.com_node(nodelist[-1])
  233.         return Lambda(names, defaults, flags, code, lineno = nodelist[1][2])
  234.  
  235.     old_lambdef = lambdef
  236.     
  237.     def classdef(self, nodelist):
  238.         name = nodelist[1][1]
  239.         doc = self.get_docstring(nodelist[-1])
  240.         if nodelist[2][0] == token.COLON:
  241.             bases = []
  242.         elif nodelist[3][0] == token.RPAR:
  243.             bases = []
  244.         else:
  245.             bases = self.com_bases(nodelist[3])
  246.         code = self.com_node(nodelist[-1])
  247.         if doc is not None:
  248.             del code.nodes[0]
  249.         
  250.         return Class(name, bases, doc, code, lineno = nodelist[1][2])
  251.  
  252.     
  253.     def stmt(self, nodelist):
  254.         return self.com_stmt(nodelist[0])
  255.  
  256.     small_stmt = stmt
  257.     flow_stmt = stmt
  258.     compound_stmt = stmt
  259.     
  260.     def simple_stmt(self, nodelist):
  261.         stmts = []
  262.         for i in range(0, len(nodelist), 2):
  263.             self.com_append_stmt(stmts, nodelist[i])
  264.         
  265.         return Stmt(stmts)
  266.  
  267.     
  268.     def parameters(self, nodelist):
  269.         raise WalkerError
  270.  
  271.     
  272.     def varargslist(self, nodelist):
  273.         raise WalkerError
  274.  
  275.     
  276.     def fpdef(self, nodelist):
  277.         raise WalkerError
  278.  
  279.     
  280.     def fplist(self, nodelist):
  281.         raise WalkerError
  282.  
  283.     
  284.     def dotted_name(self, nodelist):
  285.         raise WalkerError
  286.  
  287.     
  288.     def comp_op(self, nodelist):
  289.         raise WalkerError
  290.  
  291.     
  292.     def trailer(self, nodelist):
  293.         raise WalkerError
  294.  
  295.     
  296.     def sliceop(self, nodelist):
  297.         raise WalkerError
  298.  
  299.     
  300.     def argument(self, nodelist):
  301.         raise WalkerError
  302.  
  303.     
  304.     def expr_stmt(self, nodelist):
  305.         en = nodelist[-1]
  306.         exprNode = self.lookup_node(en)(en[1:])
  307.         if len(nodelist) == 1:
  308.             return Discard(exprNode, lineno = exprNode.lineno)
  309.         
  310.         if nodelist[1][0] == token.EQUAL:
  311.             nodesl = []
  312.             for i in range(0, len(nodelist) - 2, 2):
  313.                 nodesl.append(self.com_assign(nodelist[i], OP_ASSIGN))
  314.             
  315.             return Assign(nodesl, exprNode, lineno = nodelist[1][2])
  316.         else:
  317.             lval = self.com_augassign(nodelist[0])
  318.             op = self.com_augassign_op(nodelist[1])
  319.             return AugAssign(lval, op[1], exprNode, lineno = op[2])
  320.         raise WalkerError, "can't get here"
  321.  
  322.     
  323.     def print_stmt(self, nodelist):
  324.         items = []
  325.         if len(nodelist) == 1:
  326.             start = 1
  327.             dest = None
  328.         elif nodelist[1][0] == token.RIGHTSHIFT:
  329.             dest = self.com_node(nodelist[2])
  330.             start = 4
  331.         else:
  332.             dest = None
  333.             start = 1
  334.         for i in range(start, len(nodelist), 2):
  335.             items.append(self.com_node(nodelist[i]))
  336.         
  337.         if nodelist[-1][0] == token.COMMA:
  338.             return Print(items, dest, lineno = nodelist[0][2])
  339.         
  340.         return Printnl(items, dest, lineno = nodelist[0][2])
  341.  
  342.     
  343.     def del_stmt(self, nodelist):
  344.         return self.com_assign(nodelist[1], OP_DELETE)
  345.  
  346.     
  347.     def pass_stmt(self, nodelist):
  348.         return Pass(lineno = nodelist[0][2])
  349.  
  350.     
  351.     def break_stmt(self, nodelist):
  352.         return Break(lineno = nodelist[0][2])
  353.  
  354.     
  355.     def continue_stmt(self, nodelist):
  356.         return Continue(lineno = nodelist[0][2])
  357.  
  358.     
  359.     def return_stmt(self, nodelist):
  360.         if len(nodelist) < 2:
  361.             return Return(Const(None), lineno = nodelist[0][2])
  362.         
  363.         return Return(self.com_node(nodelist[1]), lineno = nodelist[0][2])
  364.  
  365.     
  366.     def yield_stmt(self, nodelist):
  367.         expr = self.com_node(nodelist[0])
  368.         return Discard(expr, lineno = expr.lineno)
  369.  
  370.     
  371.     def yield_expr(self, nodelist):
  372.         if len(nodelist) > 1:
  373.             value = self.com_node(nodelist[1])
  374.         else:
  375.             value = Const(None)
  376.         return Yield(value, lineno = nodelist[0][2])
  377.  
  378.     
  379.     def raise_stmt(self, nodelist):
  380.         if len(nodelist) > 5:
  381.             expr3 = self.com_node(nodelist[5])
  382.         else:
  383.             expr3 = None
  384.         if len(nodelist) > 3:
  385.             expr2 = self.com_node(nodelist[3])
  386.         else:
  387.             expr2 = None
  388.         if len(nodelist) > 1:
  389.             expr1 = self.com_node(nodelist[1])
  390.         else:
  391.             expr1 = None
  392.         return Raise(expr1, expr2, expr3, lineno = nodelist[0][2])
  393.  
  394.     
  395.     def import_stmt(self, nodelist):
  396.         return self.com_node(nodelist[0])
  397.  
  398.     
  399.     def import_name(self, nodelist):
  400.         return Import(self.com_dotted_as_names(nodelist[1]), lineno = nodelist[0][2])
  401.  
  402.     
  403.     def import_from(self, nodelist):
  404.         idx = 1
  405.         while nodelist[idx][1] == '.':
  406.             idx += 1
  407.         level = idx - 1
  408.         if nodelist[idx][0] == symbol.dotted_name:
  409.             fromname = self.com_dotted_name(nodelist[idx])
  410.             idx += 1
  411.         else:
  412.             fromname = ''
  413.         if nodelist[idx + 1][0] == token.STAR:
  414.             return From(fromname, [
  415.                 ('*', None)], level, lineno = nodelist[0][2])
  416.         else:
  417.             node = nodelist[idx + 1 + (nodelist[idx + 1][0] == token.LPAR)]
  418.             return From(fromname, self.com_import_as_names(node), level, lineno = nodelist[0][2])
  419.  
  420.     
  421.     def global_stmt(self, nodelist):
  422.         names = []
  423.         for i in range(1, len(nodelist), 2):
  424.             names.append(nodelist[i][1])
  425.         
  426.         return Global(names, lineno = nodelist[0][2])
  427.  
  428.     
  429.     def exec_stmt(self, nodelist):
  430.         expr1 = self.com_node(nodelist[1])
  431.         if len(nodelist) >= 4:
  432.             expr2 = self.com_node(nodelist[3])
  433.             if len(nodelist) >= 6:
  434.                 expr3 = self.com_node(nodelist[5])
  435.             else:
  436.                 expr3 = None
  437.         else:
  438.             expr2 = None
  439.             expr3 = None
  440.         return Exec(expr1, expr2, expr3, lineno = nodelist[0][2])
  441.  
  442.     
  443.     def assert_stmt(self, nodelist):
  444.         expr1 = self.com_node(nodelist[1])
  445.         if len(nodelist) == 4:
  446.             expr2 = self.com_node(nodelist[3])
  447.         else:
  448.             expr2 = None
  449.         return Assert(expr1, expr2, lineno = nodelist[0][2])
  450.  
  451.     
  452.     def if_stmt(self, nodelist):
  453.         tests = []
  454.         for i in range(0, len(nodelist) - 3, 4):
  455.             testNode = self.com_node(nodelist[i + 1])
  456.             suiteNode = self.com_node(nodelist[i + 3])
  457.             tests.append((testNode, suiteNode))
  458.         
  459.         if len(nodelist) % 4 == 3:
  460.             elseNode = self.com_node(nodelist[-1])
  461.         else:
  462.             elseNode = None
  463.         return If(tests, elseNode, lineno = nodelist[0][2])
  464.  
  465.     
  466.     def while_stmt(self, nodelist):
  467.         testNode = self.com_node(nodelist[1])
  468.         bodyNode = self.com_node(nodelist[3])
  469.         if len(nodelist) > 4:
  470.             elseNode = self.com_node(nodelist[6])
  471.         else:
  472.             elseNode = None
  473.         return While(testNode, bodyNode, elseNode, lineno = nodelist[0][2])
  474.  
  475.     
  476.     def for_stmt(self, nodelist):
  477.         assignNode = self.com_assign(nodelist[1], OP_ASSIGN)
  478.         listNode = self.com_node(nodelist[3])
  479.         bodyNode = self.com_node(nodelist[5])
  480.         if len(nodelist) > 8:
  481.             elseNode = self.com_node(nodelist[8])
  482.         else:
  483.             elseNode = None
  484.         return For(assignNode, listNode, bodyNode, elseNode, lineno = nodelist[0][2])
  485.  
  486.     
  487.     def try_stmt(self, nodelist):
  488.         return self.com_try_except_finally(nodelist)
  489.  
  490.     
  491.     def with_stmt(self, nodelist):
  492.         return self.com_with(nodelist)
  493.  
  494.     
  495.     def with_var(self, nodelist):
  496.         return self.com_with_var(nodelist)
  497.  
  498.     
  499.     def suite(self, nodelist):
  500.         if len(nodelist) == 1:
  501.             return self.com_stmt(nodelist[0])
  502.         
  503.         stmts = []
  504.         for node in nodelist:
  505.             if node[0] == symbol.stmt:
  506.                 self.com_append_stmt(stmts, node)
  507.                 continue
  508.         
  509.         return Stmt(stmts)
  510.  
  511.     
  512.     def testlist(self, nodelist):
  513.         return self.com_binary(Tuple, nodelist)
  514.  
  515.     testlist_safe = testlist
  516.     testlist1 = testlist
  517.     exprlist = testlist
  518.     
  519.     def testlist_gexp(self, nodelist):
  520.         if len(nodelist) == 2 and nodelist[1][0] == symbol.gen_for:
  521.             test = self.com_node(nodelist[0])
  522.             return self.com_generator_expression(test, nodelist[1])
  523.         
  524.         return self.testlist(nodelist)
  525.  
  526.     
  527.     def test(self, nodelist):
  528.         if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
  529.             return self.lambdef(nodelist[0])
  530.         
  531.         then = self.com_node(nodelist[0])
  532.         if len(nodelist) > 1:
  533.             test = self.com_node(nodelist[2])
  534.             else_ = self.com_node(nodelist[4])
  535.             return IfExp(test, then, else_, lineno = nodelist[1][2])
  536.         
  537.         return then
  538.  
  539.     
  540.     def or_test(self, nodelist):
  541.         if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
  542.             return self.lambdef(nodelist[0])
  543.         
  544.         return self.com_binary(Or, nodelist)
  545.  
  546.     old_test = or_test
  547.     
  548.     def and_test(self, nodelist):
  549.         return self.com_binary(And, nodelist)
  550.  
  551.     
  552.     def not_test(self, nodelist):
  553.         result = self.com_node(nodelist[-1])
  554.         if len(nodelist) == 2:
  555.             return Not(result, lineno = nodelist[0][2])
  556.         
  557.         return result
  558.  
  559.     
  560.     def comparison(self, nodelist):
  561.         node = self.com_node(nodelist[0])
  562.         if len(nodelist) == 1:
  563.             return node
  564.         
  565.         results = []
  566.         for i in range(2, len(nodelist), 2):
  567.             nl = nodelist[i - 1]
  568.             n = nl[1]
  569.             if n[0] == token.NAME:
  570.                 type = n[1]
  571.                 if len(nl) == 3:
  572.                     if type == 'not':
  573.                         type = 'not in'
  574.                     else:
  575.                         type = 'is not'
  576.                 
  577.             else:
  578.                 type = _cmp_types[n[0]]
  579.             lineno = nl[1][2]
  580.             results.append((type, self.com_node(nodelist[i])))
  581.         
  582.         return Compare(node, results, lineno = lineno)
  583.  
  584.     
  585.     def expr(self, nodelist):
  586.         return self.com_binary(Bitor, nodelist)
  587.  
  588.     
  589.     def xor_expr(self, nodelist):
  590.         return self.com_binary(Bitxor, nodelist)
  591.  
  592.     
  593.     def and_expr(self, nodelist):
  594.         return self.com_binary(Bitand, nodelist)
  595.  
  596.     
  597.     def shift_expr(self, nodelist):
  598.         node = self.com_node(nodelist[0])
  599.         for i in range(2, len(nodelist), 2):
  600.             right = self.com_node(nodelist[i])
  601.             if nodelist[i - 1][0] == token.LEFTSHIFT:
  602.                 node = LeftShift([
  603.                     node,
  604.                     right], lineno = nodelist[1][2])
  605.                 continue
  606.             if nodelist[i - 1][0] == token.RIGHTSHIFT:
  607.                 node = RightShift([
  608.                     node,
  609.                     right], lineno = nodelist[1][2])
  610.                 continue
  611.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  612.         
  613.         return node
  614.  
  615.     
  616.     def arith_expr(self, nodelist):
  617.         node = self.com_node(nodelist[0])
  618.         for i in range(2, len(nodelist), 2):
  619.             right = self.com_node(nodelist[i])
  620.             if nodelist[i - 1][0] == token.PLUS:
  621.                 node = Add([
  622.                     node,
  623.                     right], lineno = nodelist[1][2])
  624.                 continue
  625.             if nodelist[i - 1][0] == token.MINUS:
  626.                 node = Sub([
  627.                     node,
  628.                     right], lineno = nodelist[1][2])
  629.                 continue
  630.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  631.         
  632.         return node
  633.  
  634.     
  635.     def term(self, nodelist):
  636.         node = self.com_node(nodelist[0])
  637.         for i in range(2, len(nodelist), 2):
  638.             right = self.com_node(nodelist[i])
  639.             t = nodelist[i - 1][0]
  640.             if t == token.STAR:
  641.                 node = Mul([
  642.                     node,
  643.                     right])
  644.             elif t == token.SLASH:
  645.                 node = Div([
  646.                     node,
  647.                     right])
  648.             elif t == token.PERCENT:
  649.                 node = Mod([
  650.                     node,
  651.                     right])
  652.             elif t == token.DOUBLESLASH:
  653.                 node = FloorDiv([
  654.                     node,
  655.                     right])
  656.             else:
  657.                 raise ValueError, 'unexpected token: %s' % t
  658.             node.lineno = nodelist[1][2]
  659.         
  660.         return node
  661.  
  662.     
  663.     def factor(self, nodelist):
  664.         elt = nodelist[0]
  665.         t = elt[0]
  666.         node = self.lookup_node(nodelist[-1])(nodelist[-1][1:])
  667.         if t == token.PLUS:
  668.             return UnaryAdd(node, lineno = elt[2])
  669.         elif t == token.MINUS:
  670.             return UnarySub(node, lineno = elt[2])
  671.         elif t == token.TILDE:
  672.             node = Invert(node, lineno = elt[2])
  673.         
  674.         return node
  675.  
  676.     
  677.     def power(self, nodelist):
  678.         node = self.com_node(nodelist[0])
  679.         for i in range(1, len(nodelist)):
  680.             elt = nodelist[i]
  681.             if elt[0] == token.DOUBLESTAR:
  682.                 return Power([
  683.                     node,
  684.                     self.com_node(nodelist[i + 1])], lineno = elt[2])
  685.             
  686.             node = self.com_apply_trailer(node, elt)
  687.         
  688.         return node
  689.  
  690.     
  691.     def atom(self, nodelist):
  692.         return self._atom_dispatch[nodelist[0][0]](nodelist)
  693.  
  694.     
  695.     def atom_lpar(self, nodelist):
  696.         if nodelist[1][0] == token.RPAR:
  697.             return Tuple((), lineno = nodelist[0][2])
  698.         
  699.         return self.com_node(nodelist[1])
  700.  
  701.     
  702.     def atom_lsqb(self, nodelist):
  703.         if nodelist[1][0] == token.RSQB:
  704.             return List((), lineno = nodelist[0][2])
  705.         
  706.         return self.com_list_constructor(nodelist[1])
  707.  
  708.     
  709.     def atom_lbrace(self, nodelist):
  710.         if nodelist[1][0] == token.RBRACE:
  711.             return Dict((), lineno = nodelist[0][2])
  712.         
  713.         return self.com_dictmaker(nodelist[1])
  714.  
  715.     
  716.     def atom_backquote(self, nodelist):
  717.         return Backquote(self.com_node(nodelist[1]))
  718.  
  719.     
  720.     def atom_number(self, nodelist):
  721.         k = eval(nodelist[0][1])
  722.         return Const(k, lineno = nodelist[0][2])
  723.  
  724.     
  725.     def decode_literal(self, lit):
  726.         if self.encoding:
  727.             if self.encoding not in ('utf-8', 'iso-8859-1'):
  728.                 lit = unicode(lit, 'utf-8').encode(self.encoding)
  729.             
  730.             return eval('# coding: %s\n%s' % (self.encoding, lit))
  731.         else:
  732.             return eval(lit)
  733.  
  734.     
  735.     def atom_string(self, nodelist):
  736.         k = ''
  737.         for node in nodelist:
  738.             k += self.decode_literal(node[1])
  739.         
  740.         return Const(k, lineno = nodelist[0][2])
  741.  
  742.     
  743.     def atom_name(self, nodelist):
  744.         return Name(nodelist[0][1], lineno = nodelist[0][2])
  745.  
  746.     
  747.     def lookup_node(self, node):
  748.         return self._dispatch[node[0]]
  749.  
  750.     
  751.     def com_node(self, node):
  752.         return self._dispatch[node[0]](node[1:])
  753.  
  754.     
  755.     def com_NEWLINE(self, *args):
  756.         return Discard(Const(None))
  757.  
  758.     
  759.     def com_arglist(self, nodelist):
  760.         names = []
  761.         defaults = []
  762.         flags = 0
  763.         i = 0
  764.         while i < len(nodelist):
  765.             node = nodelist[i]
  766.             if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
  767.                 if node[0] == token.STAR:
  768.                     node = nodelist[i + 1]
  769.                     if node[0] == token.NAME:
  770.                         names.append(node[1])
  771.                         flags = flags | CO_VARARGS
  772.                         i = i + 3
  773.                     
  774.                 
  775.                 if i < len(nodelist):
  776.                     t = nodelist[i][0]
  777.                     if t == token.DOUBLESTAR:
  778.                         node = nodelist[i + 1]
  779.                     else:
  780.                         raise ValueError, 'unexpected token: %s' % t
  781.                     names.append(node[1])
  782.                     flags = flags | CO_VARKEYWORDS
  783.                 
  784.                 break
  785.             
  786.             names.append(self.com_fpdef(node))
  787.             i = i + 1
  788.             if i < len(nodelist) and nodelist[i][0] == token.EQUAL:
  789.                 defaults.append(self.com_node(nodelist[i + 1]))
  790.                 i = i + 2
  791.             elif len(defaults):
  792.                 raise SyntaxError, 'non-default argument follows default argument'
  793.             
  794.             i = i + 1
  795.         return (names, defaults, flags)
  796.  
  797.     
  798.     def com_fpdef(self, node):
  799.         if node[1][0] == token.LPAR:
  800.             return self.com_fplist(node[2])
  801.         
  802.         return node[1][1]
  803.  
  804.     
  805.     def com_fplist(self, node):
  806.         if len(node) == 2:
  807.             return self.com_fpdef(node[1])
  808.         
  809.         list = []
  810.         for i in range(1, len(node), 2):
  811.             list.append(self.com_fpdef(node[i]))
  812.         
  813.         return tuple(list)
  814.  
  815.     
  816.     def com_dotted_name(self, node):
  817.         name = ''
  818.         for n in node:
  819.             if type(n) == type(()) and n[0] == 1:
  820.                 name = name + n[1] + '.'
  821.                 continue
  822.         
  823.         return name[:-1]
  824.  
  825.     
  826.     def com_dotted_as_name(self, node):
  827.         node = node[1:]
  828.         dot = self.com_dotted_name(node[0][1:])
  829.         if len(node) == 1:
  830.             return (dot, None)
  831.         
  832.         return (dot, node[2][1])
  833.  
  834.     
  835.     def com_dotted_as_names(self, node):
  836.         node = node[1:]
  837.         names = [
  838.             self.com_dotted_as_name(node[0])]
  839.         for i in range(2, len(node), 2):
  840.             names.append(self.com_dotted_as_name(node[i]))
  841.         
  842.         return names
  843.  
  844.     
  845.     def com_import_as_name(self, node):
  846.         node = node[1:]
  847.         if len(node) == 1:
  848.             return (node[0][1], None)
  849.         
  850.         return (node[0][1], node[2][1])
  851.  
  852.     
  853.     def com_import_as_names(self, node):
  854.         node = node[1:]
  855.         names = [
  856.             self.com_import_as_name(node[0])]
  857.         for i in range(2, len(node), 2):
  858.             names.append(self.com_import_as_name(node[i]))
  859.         
  860.         return names
  861.  
  862.     
  863.     def com_bases(self, node):
  864.         bases = []
  865.         for i in range(1, len(node), 2):
  866.             bases.append(self.com_node(node[i]))
  867.         
  868.         return bases
  869.  
  870.     
  871.     def com_try_except_finally(self, nodelist):
  872.         if nodelist[3][0] == token.NAME:
  873.             return TryFinally(self.com_node(nodelist[2]), self.com_node(nodelist[5]), lineno = nodelist[0][2])
  874.         
  875.         clauses = []
  876.         elseNode = None
  877.         finallyNode = None
  878.         for i in range(3, len(nodelist), 3):
  879.             node = nodelist[i]
  880.             if node[0] == symbol.except_clause:
  881.                 if len(node) > 2:
  882.                     expr1 = self.com_node(node[2])
  883.                     if len(node) > 4:
  884.                         expr2 = self.com_assign(node[4], OP_ASSIGN)
  885.                     else:
  886.                         expr2 = None
  887.                 else:
  888.                     expr1 = None
  889.                     expr2 = None
  890.                 clauses.append((expr1, expr2, self.com_node(nodelist[i + 2])))
  891.             
  892.             if node[0] == token.NAME:
  893.                 if node[1] == 'else':
  894.                     elseNode = self.com_node(nodelist[i + 2])
  895.                 elif node[1] == 'finally':
  896.                     finallyNode = self.com_node(nodelist[i + 2])
  897.                 
  898.             node[1] == 'else'
  899.         
  900.         try_except = TryExcept(self.com_node(nodelist[2]), clauses, elseNode, lineno = nodelist[0][2])
  901.         if finallyNode:
  902.             return TryFinally(try_except, finallyNode, lineno = nodelist[0][2])
  903.         else:
  904.             return try_except
  905.  
  906.     
  907.     def com_with(self, nodelist):
  908.         expr = self.com_node(nodelist[1])
  909.         body = self.com_node(nodelist[-1])
  910.         if nodelist[2][0] == token.COLON:
  911.             var = None
  912.         else:
  913.             var = self.com_assign(nodelist[2][2], OP_ASSIGN)
  914.         return With(expr, var, body, lineno = nodelist[0][2])
  915.  
  916.     
  917.     def com_with_var(self, nodelist):
  918.         return self.com_node(nodelist[1])
  919.  
  920.     
  921.     def com_augassign_op(self, node):
  922.         return node[1]
  923.  
  924.     
  925.     def com_augassign(self, node):
  926.         l = self.com_node(node)
  927.         if l.__class__ in (Name, Slice, Subscript, Getattr):
  928.             return l
  929.         
  930.         raise SyntaxError, "can't assign to %s" % l.__class__.__name__
  931.  
  932.     
  933.     def com_assign(self, node, assigning):
  934.         while None:
  935.             t = node[0]
  936.             if t in (symbol.exprlist, symbol.testlist, symbol.testlist_safe, symbol.testlist_gexp):
  937.                 if len(node) > 2:
  938.                     return self.com_assign_tuple(node, assigning)
  939.                 
  940.                 node = node[1]
  941.                 continue
  942.             if t in _assign_types:
  943.                 if len(node) > 2:
  944.                     raise SyntaxError, "can't assign to operator"
  945.                 
  946.                 node = node[1]
  947.                 continue
  948.             None if t == symbol.power else t == token.LPAR
  949.             raise SyntaxError, 'bad assignment (%s)' % t
  950.             continue
  951.             return None
  952.  
  953.     
  954.     def com_assign_tuple(self, node, assigning):
  955.         assigns = []
  956.         for i in range(1, len(node), 2):
  957.             assigns.append(self.com_assign(node[i], assigning))
  958.         
  959.         return AssTuple(assigns, lineno = extractLineNo(node))
  960.  
  961.     
  962.     def com_assign_list(self, node, assigning):
  963.         assigns = []
  964.         for i in range(1, len(node), 2):
  965.             if i + 1 < len(node):
  966.                 if node[i + 1][0] == symbol.list_for:
  967.                     raise SyntaxError, "can't assign to list comprehension"
  968.                 
  969.             
  970.             assigns.append(self.com_assign(node[i], assigning))
  971.         
  972.         return AssList(assigns, lineno = extractLineNo(node))
  973.  
  974.     
  975.     def com_assign_name(self, node, assigning):
  976.         return AssName(node[1], assigning, lineno = node[2])
  977.  
  978.     
  979.     def com_assign_trailer(self, primary, node, assigning):
  980.         t = node[1][0]
  981.         if t == token.DOT:
  982.             return self.com_assign_attr(primary, node[2], assigning)
  983.         
  984.         if t == token.LSQB:
  985.             return self.com_subscriptlist(primary, node[2], assigning)
  986.         
  987.         if t == token.LPAR:
  988.             raise SyntaxError, "can't assign to function call"
  989.         
  990.         raise SyntaxError, 'unknown trailer type: %s' % t
  991.  
  992.     
  993.     def com_assign_attr(self, primary, node, assigning):
  994.         return AssAttr(primary, node[1], assigning, lineno = node[-1])
  995.  
  996.     
  997.     def com_binary(self, constructor, nodelist):
  998.         l = len(nodelist)
  999.         if l == 1:
  1000.             n = nodelist[0]
  1001.             return self.lookup_node(n)(n[1:])
  1002.         
  1003.         items = []
  1004.         for i in range(0, l, 2):
  1005.             n = nodelist[i]
  1006.             items.append(self.lookup_node(n)(n[1:]))
  1007.         
  1008.         return constructor(items, lineno = extractLineNo(nodelist))
  1009.  
  1010.     
  1011.     def com_stmt(self, node):
  1012.         result = self.lookup_node(node)(node[1:])
  1013.         if isinstance(result, Stmt):
  1014.             return result
  1015.         
  1016.         return Stmt([
  1017.             result])
  1018.  
  1019.     
  1020.     def com_append_stmt(self, stmts, node):
  1021.         result = self.lookup_node(node)(node[1:])
  1022.         if isinstance(result, Stmt):
  1023.             stmts.extend(result.nodes)
  1024.         else:
  1025.             stmts.append(result)
  1026.  
  1027.     if hasattr(symbol, 'list_for'):
  1028.         
  1029.         def com_list_constructor(self, nodelist):
  1030.             values = []
  1031.             for i in range(1, len(nodelist)):
  1032.                 if nodelist[i][0] == symbol.list_for:
  1033.                     return self.com_list_comprehension(values[0], nodelist[i])
  1034.                 elif nodelist[i][0] == token.COMMA:
  1035.                     continue
  1036.                 
  1037.                 values.append(self.com_node(nodelist[i]))
  1038.             
  1039.             return List(values, lineno = values[0].lineno)
  1040.  
  1041.         
  1042.         def com_list_comprehension(self, expr, node):
  1043.             lineno = node[1][2]
  1044.             fors = []
  1045.             while node:
  1046.                 t = node[1][1]
  1047.                 if t == 'for':
  1048.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1049.                     listNode = self.com_node(node[4])
  1050.                     newfor = ListCompFor(assignNode, listNode, [])
  1051.                     newfor.lineno = node[1][2]
  1052.                     fors.append(newfor)
  1053.                     if len(node) == 5:
  1054.                         node = None
  1055.                     else:
  1056.                         node = self.com_list_iter(node[5])
  1057.                 len(node) == 5
  1058.                 if t == 'if':
  1059.                     test = self.com_node(node[2])
  1060.                     newif = ListCompIf(test, lineno = node[1][2])
  1061.                     newfor.ifs.append(newif)
  1062.                     if len(node) == 3:
  1063.                         node = None
  1064.                     else:
  1065.                         node = self.com_list_iter(node[3])
  1066.                 len(node) == 3
  1067.                 raise SyntaxError, 'unexpected list comprehension element: %s %d' % (node, lineno)
  1068.             return ListComp(expr, fors, lineno = lineno)
  1069.  
  1070.         
  1071.         def com_list_iter(self, node):
  1072.             return node[1]
  1073.  
  1074.     else:
  1075.         
  1076.         def com_list_constructor(self, nodelist):
  1077.             values = []
  1078.             for i in range(1, len(nodelist), 2):
  1079.                 values.append(self.com_node(nodelist[i]))
  1080.             
  1081.             return List(values, lineno = values[0].lineno)
  1082.  
  1083.     if hasattr(symbol, 'gen_for'):
  1084.         
  1085.         def com_generator_expression(self, expr, node):
  1086.             lineno = node[1][2]
  1087.             fors = []
  1088.             while node:
  1089.                 t = node[1][1]
  1090.                 if t == 'for':
  1091.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1092.                     genNode = self.com_node(node[4])
  1093.                     newfor = GenExprFor(assignNode, genNode, [], lineno = node[1][2])
  1094.                     fors.append(newfor)
  1095.                     if len(node) == 5:
  1096.                         node = None
  1097.                     else:
  1098.                         node = self.com_gen_iter(node[5])
  1099.                 len(node) == 5
  1100.                 if t == 'if':
  1101.                     test = self.com_node(node[2])
  1102.                     newif = GenExprIf(test, lineno = node[1][2])
  1103.                     newfor.ifs.append(newif)
  1104.                     if len(node) == 3:
  1105.                         node = None
  1106.                     else:
  1107.                         node = self.com_gen_iter(node[3])
  1108.                 len(node) == 3
  1109.                 raise SyntaxError, 'unexpected generator expression element: %s %d' % (node, lineno)
  1110.             fors[0].is_outmost = True
  1111.             return GenExpr(GenExprInner(expr, fors), lineno = lineno)
  1112.  
  1113.         
  1114.         def com_gen_iter(self, node):
  1115.             return node[1]
  1116.  
  1117.     
  1118.     
  1119.     def com_dictmaker(self, nodelist):
  1120.         items = []
  1121.         for i in range(1, len(nodelist), 4):
  1122.             items.append((self.com_node(nodelist[i]), self.com_node(nodelist[i + 2])))
  1123.         
  1124.         return Dict(items, lineno = items[0][0].lineno)
  1125.  
  1126.     
  1127.     def com_apply_trailer(self, primaryNode, nodelist):
  1128.         t = nodelist[1][0]
  1129.         if t == token.LPAR:
  1130.             return self.com_call_function(primaryNode, nodelist[2])
  1131.         
  1132.         if t == token.DOT:
  1133.             return self.com_select_member(primaryNode, nodelist[2])
  1134.         
  1135.         if t == token.LSQB:
  1136.             return self.com_subscriptlist(primaryNode, nodelist[2], OP_APPLY)
  1137.         
  1138.         raise SyntaxError, 'unknown node type: %s' % t
  1139.  
  1140.     
  1141.     def com_select_member(self, primaryNode, nodelist):
  1142.         if nodelist[0] != token.NAME:
  1143.             raise SyntaxError, 'member must be a name'
  1144.         
  1145.         return Getattr(primaryNode, nodelist[1], lineno = nodelist[2])
  1146.  
  1147.     
  1148.     def com_call_function(self, primaryNode, nodelist):
  1149.         if nodelist[0] == token.RPAR:
  1150.             return CallFunc(primaryNode, [], lineno = extractLineNo(nodelist))
  1151.         
  1152.         args = []
  1153.         kw = 0
  1154.         len_nodelist = len(nodelist)
  1155.         for i in range(1, len_nodelist, 2):
  1156.             node = nodelist[i]
  1157.             if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
  1158.                 break
  1159.             
  1160.             (kw, result) = self.com_argument(node, kw)
  1161.             if len_nodelist != 2 and isinstance(result, GenExpr) and len(node) == 3 and node[2][0] == symbol.gen_for:
  1162.                 raise SyntaxError, 'generator expression needs parenthesis'
  1163.             
  1164.             args.append(result)
  1165.         else:
  1166.             i = i + 1
  1167.         if i < len_nodelist and nodelist[i][0] == token.COMMA:
  1168.             i = i + 1
  1169.         
  1170.         star_node = None
  1171.         dstar_node = None
  1172.         while i < len_nodelist:
  1173.             tok = nodelist[i]
  1174.             ch = nodelist[i + 1]
  1175.             i = i + 3
  1176.             if tok[0] == token.STAR:
  1177.                 if star_node is not None:
  1178.                     raise SyntaxError, 'already have the varargs indentifier'
  1179.                 
  1180.                 star_node = self.com_node(ch)
  1181.                 continue
  1182.             if tok[0] == token.DOUBLESTAR:
  1183.                 if dstar_node is not None:
  1184.                     raise SyntaxError, 'already have the kwargs indentifier'
  1185.                 
  1186.                 dstar_node = self.com_node(ch)
  1187.                 continue
  1188.             raise SyntaxError, 'unknown node type: %s' % tok
  1189.         return CallFunc(primaryNode, args, star_node, dstar_node, lineno = extractLineNo(nodelist))
  1190.  
  1191.     
  1192.     def com_argument(self, nodelist, kw):
  1193.         if len(nodelist) == 3 and nodelist[2][0] == symbol.gen_for:
  1194.             test = self.com_node(nodelist[1])
  1195.             return (0, self.com_generator_expression(test, nodelist[2]))
  1196.         
  1197.         if len(nodelist) == 2:
  1198.             if kw:
  1199.                 raise SyntaxError, 'non-keyword arg after keyword arg'
  1200.             
  1201.             return (0, self.com_node(nodelist[1]))
  1202.         
  1203.         result = self.com_node(nodelist[3])
  1204.         n = nodelist[1]
  1205.         while len(n) == 2 and n[0] != token.NAME:
  1206.             n = n[1]
  1207.         if n[0] != token.NAME:
  1208.             raise SyntaxError, "keyword can't be an expression (%s)" % n[0]
  1209.         
  1210.         node = Keyword(n[1], result, lineno = n[2])
  1211.         return (1, node)
  1212.  
  1213.     
  1214.     def com_subscriptlist(self, primary, nodelist, assigning):
  1215.         if len(nodelist) == 2:
  1216.             sub = nodelist[1]
  1217.             if (sub[1][0] == token.COLON or len(sub) > 2 or sub[2][0] == token.COLON) and sub[-1][0] != symbol.sliceop:
  1218.                 return self.com_slice(primary, sub, assigning)
  1219.             
  1220.         
  1221.         subscripts = []
  1222.         for i in range(1, len(nodelist), 2):
  1223.             subscripts.append(self.com_subscript(nodelist[i]))
  1224.         
  1225.         return Subscript(primary, assigning, subscripts, lineno = extractLineNo(nodelist))
  1226.  
  1227.     
  1228.     def com_subscript(self, node):
  1229.         ch = node[1]
  1230.         t = ch[0]
  1231.         if t == token.DOT and node[2][0] == token.DOT:
  1232.             return Ellipsis()
  1233.         
  1234.         if t == token.COLON or len(node) > 2:
  1235.             return self.com_sliceobj(node)
  1236.         
  1237.         return self.com_node(ch)
  1238.  
  1239.     
  1240.     def com_sliceobj(self, node):
  1241.         items = []
  1242.         if node[1][0] == token.COLON:
  1243.             items.append(Const(None))
  1244.             i = 2
  1245.         else:
  1246.             items.append(self.com_node(node[1]))
  1247.             i = 3
  1248.         if i < len(node) and node[i][0] == symbol.test:
  1249.             items.append(self.com_node(node[i]))
  1250.             i = i + 1
  1251.         else:
  1252.             items.append(Const(None))
  1253.         for j in range(i, len(node)):
  1254.             ch = node[j]
  1255.             if len(ch) == 2:
  1256.                 items.append(Const(None))
  1257.                 continue
  1258.             items.append(self.com_node(ch[2]))
  1259.         
  1260.         return Sliceobj(items, lineno = extractLineNo(node))
  1261.  
  1262.     
  1263.     def com_slice(self, primary, node, assigning):
  1264.         lower = None
  1265.         upper = None
  1266.         if len(node) == 3:
  1267.             if node[1][0] == token.COLON:
  1268.                 upper = self.com_node(node[2])
  1269.             else:
  1270.                 lower = self.com_node(node[1])
  1271.         elif len(node) == 4:
  1272.             lower = self.com_node(node[1])
  1273.             upper = self.com_node(node[3])
  1274.         
  1275.         return Slice(primary, assigning, lower, upper, lineno = extractLineNo(node))
  1276.  
  1277.     
  1278.     def get_docstring(self, node, n = None):
  1279.         if n is None:
  1280.             n = node[0]
  1281.             node = node[1:]
  1282.         
  1283.         if n == symbol.suite:
  1284.             if len(node) == 1:
  1285.                 return self.get_docstring(node[0])
  1286.             
  1287.             for sub in node:
  1288.                 if sub[0] == symbol.stmt:
  1289.                     return self.get_docstring(sub)
  1290.                     continue
  1291.             
  1292.             return None
  1293.         
  1294.         if n == symbol.file_input:
  1295.             for sub in node:
  1296.                 if sub[0] == symbol.stmt:
  1297.                     return self.get_docstring(sub)
  1298.                     continue
  1299.             
  1300.             return None
  1301.         
  1302.         if n == symbol.atom:
  1303.             if node[0][0] == token.STRING:
  1304.                 s = ''
  1305.                 for t in node:
  1306.                     s = s + eval(t[1])
  1307.                 
  1308.                 return s
  1309.             
  1310.             return None
  1311.         
  1312.         if n == symbol.stmt and n == symbol.simple_stmt or n == symbol.small_stmt:
  1313.             return self.get_docstring(node[0])
  1314.         
  1315.         if n in _doc_nodes and len(node) == 1:
  1316.             return self.get_docstring(node[0])
  1317.         
  1318.  
  1319.  
  1320. _doc_nodes = [
  1321.     symbol.expr_stmt,
  1322.     symbol.testlist,
  1323.     symbol.testlist_safe,
  1324.     symbol.test,
  1325.     symbol.or_test,
  1326.     symbol.and_test,
  1327.     symbol.not_test,
  1328.     symbol.comparison,
  1329.     symbol.expr,
  1330.     symbol.xor_expr,
  1331.     symbol.and_expr,
  1332.     symbol.shift_expr,
  1333.     symbol.arith_expr,
  1334.     symbol.term,
  1335.     symbol.factor,
  1336.     symbol.power]
  1337. _cmp_types = {
  1338.     token.LESS: '<',
  1339.     token.GREATER: '>',
  1340.     token.EQEQUAL: '==',
  1341.     token.EQUAL: '==',
  1342.     token.LESSEQUAL: '<=',
  1343.     token.GREATEREQUAL: '>=',
  1344.     token.NOTEQUAL: '!=' }
  1345. _legal_node_types = [
  1346.     symbol.funcdef,
  1347.     symbol.classdef,
  1348.     symbol.stmt,
  1349.     symbol.small_stmt,
  1350.     symbol.flow_stmt,
  1351.     symbol.simple_stmt,
  1352.     symbol.compound_stmt,
  1353.     symbol.expr_stmt,
  1354.     symbol.print_stmt,
  1355.     symbol.del_stmt,
  1356.     symbol.pass_stmt,
  1357.     symbol.break_stmt,
  1358.     symbol.continue_stmt,
  1359.     symbol.return_stmt,
  1360.     symbol.raise_stmt,
  1361.     symbol.import_stmt,
  1362.     symbol.global_stmt,
  1363.     symbol.exec_stmt,
  1364.     symbol.assert_stmt,
  1365.     symbol.if_stmt,
  1366.     symbol.while_stmt,
  1367.     symbol.for_stmt,
  1368.     symbol.try_stmt,
  1369.     symbol.with_stmt,
  1370.     symbol.suite,
  1371.     symbol.testlist,
  1372.     symbol.testlist_safe,
  1373.     symbol.test,
  1374.     symbol.and_test,
  1375.     symbol.not_test,
  1376.     symbol.comparison,
  1377.     symbol.exprlist,
  1378.     symbol.expr,
  1379.     symbol.xor_expr,
  1380.     symbol.and_expr,
  1381.     symbol.shift_expr,
  1382.     symbol.arith_expr,
  1383.     symbol.term,
  1384.     symbol.factor,
  1385.     symbol.power,
  1386.     symbol.atom]
  1387. if hasattr(symbol, 'yield_stmt'):
  1388.     _legal_node_types.append(symbol.yield_stmt)
  1389.  
  1390. if hasattr(symbol, 'yield_expr'):
  1391.     _legal_node_types.append(symbol.yield_expr)
  1392.  
  1393. _assign_types = [
  1394.     symbol.test,
  1395.     symbol.or_test,
  1396.     symbol.and_test,
  1397.     symbol.not_test,
  1398.     symbol.comparison,
  1399.     symbol.expr,
  1400.     symbol.xor_expr,
  1401.     symbol.and_expr,
  1402.     symbol.shift_expr,
  1403.     symbol.arith_expr,
  1404.     symbol.term,
  1405.     symbol.factor]
  1406. _names = { }
  1407. for k, v in symbol.sym_name.items():
  1408.     _names[k] = v
  1409.  
  1410. for k, v in token.tok_name.items():
  1411.     _names[k] = v
  1412.  
  1413.  
  1414. def debug_tree(tree):
  1415.     l = []
  1416.     for elt in tree:
  1417.         if isinstance(elt, int):
  1418.             l.append(_names.get(elt, elt))
  1419.             continue
  1420.         if isinstance(elt, str):
  1421.             l.append(elt)
  1422.             continue
  1423.         l.append(debug_tree(elt))
  1424.     
  1425.     return l
  1426.  
  1427.